package com.ruoyi.order.Utils;

import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.ruoyi.H5Send.util.ChuangLanSmsUtil;
import com.ruoyi.agent.domain.SysAgent;
import com.ruoyi.agent.mapper.SysAgentMapper;
import com.ruoyi.common.exception.ServiceException;
import com.ruoyi.order.domain.SysOrderOne;
import com.ruoyi.order.mapper.SysOrderOneMapper;
import com.ruoyi.store.domain.SysStore;
import com.ruoyi.store.mapper.SysStoreMapper;
import org.omg.CORBA.PRIVATE_MEMBER;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.multipart.MultipartFile;

import java.sql.SQLOutput;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;
import java.util.Random;
import java.util.regex.Pattern;

/**
 * @Description:
 * @Author: 吕宇宏
 * @Date: 2024/7/4 18:32
 */

@Component
public class OrderUtils {


    public static String MakeOrderByDate(String OnlneStatus, Date date) {


        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyyMMdd");
        String format = dateFormat.format(date);
        String OnlneHeader = "";
        String orderNum = "";
        if (OnlneStatus.equals("0")) {
            //说明是线上订单：
            OnlneHeader = "XS";

        } else if (OnlneStatus.equals("1")) {
            OnlneHeader = "XX";
        }
        String tail = generateRandomString();

        orderNum = OnlneHeader + format + tail;

        return orderNum;
    }


    // 可能的字符：大写字母和数字
    private static final String CHAR_POOL_LETTERS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    private static final String CHAR_POOL_NUMBERS = "0123456789";

    /**
     * 生成一个由大写字母和数字组成的随机四位字符串，确保至少有一个大写字母和一个数字
     *
     * @return 随机生成的四位字符串
     */
    public static String generateRandomString() {
        Random random = new Random();

        // 至少保证有一个大写字母和一个数字
        StringBuilder sb = new StringBuilder();
        boolean hasLetter = false;
        boolean hasNumber = false;

        // 第一个字符随机选择大写字母或数字
        if (random.nextBoolean()) {
            sb.append(CHAR_POOL_LETTERS.charAt(random.nextInt(CHAR_POOL_LETTERS.length())));
            hasLetter = true;
        } else {
            sb.append(CHAR_POOL_NUMBERS.charAt(random.nextInt(CHAR_POOL_NUMBERS.length())));
            hasNumber = true;
        }

        // 填充剩余的字符，确保至少有一个大写字母和一个数字
        for (int i = 1; i < 4; i++) {
            if (!hasLetter) {
                sb.append(CHAR_POOL_LETTERS.charAt(random.nextInt(CHAR_POOL_LETTERS.length())));
                hasLetter = true;
            } else if (!hasNumber) {
                sb.append(CHAR_POOL_NUMBERS.charAt(random.nextInt(CHAR_POOL_NUMBERS.length())));
                hasNumber = true;
            } else {
                // 如果已经有了大写字母和数字，随机选择
                if (i % 2 == 0) {
                    sb.append(CHAR_POOL_LETTERS.charAt(random.nextInt(CHAR_POOL_LETTERS.length())));
                } else {
                    sb.append(CHAR_POOL_NUMBERS.charAt(random.nextInt(CHAR_POOL_NUMBERS.length())));
                }

                // 为了简化，这里不区分是大写字母还是数字，但你可以根据需求调整
                // 比如使用随机数再次决定是字母还是数字
            }
        }

        // 注意：上面的逻辑在特定情况下（如非常不幸的随机数序列）可能仍然导致不满足条件
        // 但对于随机生成而言，这种情况极不常见，且可以通过增加随机性（如再次循环检查）来避免

        // 简化逻辑：由于我们已经确保了前两个字符中至少有一个是大写字母和一个数字，所以下面的循环不会破坏这个条件

        // 返回一个随机但满足条件的字符串
        return sb.toString();
    }

//    public static void main(String[] args) {
//        // 测试生成随机字符串
//
//        while (true) {
//            System.out.println(MakeMoreOrderByDate(new Date()));
//
//        }
//    }


    public static String GetNumRandomString() {
        Random random = new Random();

        // 至少保证有一个大写字母和一个数字
        StringBuilder sb = new StringBuilder();


        for (int i = 0; i < 4; i++) {
            sb.append(CHAR_POOL_NUMBERS.charAt(random.nextInt(CHAR_POOL_NUMBERS.length())));
        }

        // 注意：上面的逻辑在特定情况下（如非常不幸的随机数序列）可能仍然导致不满足条件
        // 但对于随机生成而言，这种情况极不常见，且可以通过增加随机性（如再次循环检查）来避免

        // 简化逻辑：由于我们已经确保了前两个字符中至少有一个是大写字母和一个数字，所以下面的循环不会破坏这个条件

        // 返回一个随机但满足条件的字符串
        return sb.toString();
    }

    public static String MakeMoreOrderByDate(Date date) {


        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyyMMdd");
        String format = dateFormat.format(date);

        String orderNum = "";

        String tail = GetNumRandomString();
        orderNum = format + tail;

        return orderNum;
    }

    // 用于计算校验码的加权因子
    private static final int[] WEIGHT_FACTORS = {7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2};
    // 校验码对应值
    private static final char[] CHECK_CODES = {'1', '0', 'X', '9', '8', '7', '6', '5', '4', '3', '2'};

    /**
     * 校验18位身份证号码是否合法
     *
     * @param idCard 18位身份证号码
     * @return 是否合法
     */
    public static boolean isValidIDCard18(String idCard) {
        if (idCard == null || idCard.length() != 18) {
            return false;
        }
        // 校验前17位是否全为数字
        for (int i = 0; i < 17; i++) {
            if (!Character.isDigit(idCard.charAt(i))) {
                return false;
            }
        }
        // 校验最后一位
        return isValidCheckCode(idCard.substring(0, 17), idCard.charAt(17));
    }

    /**
     * 校验最后一位校验码是否正确
     *
     * @param base      前17位身份证号码
     * @param checkCode 最后一位校验码
     * @return 校验码是否正确
     */
    private static boolean isValidCheckCode(String base, char checkCode) {
        int sum = 0;
        for (int i = 0; i < 17; i++) {
            sum += Integer.parseInt(base.charAt(i) + "") * WEIGHT_FACTORS[i];
        }
        int mod = sum % 11;
        return mod < CHECK_CODES.length && CHECK_CODES[mod] == Character.toUpperCase(checkCode);
    }

    // 注意：这里没有提供15位身份证的校验逻辑，因为它主要是基于日期校验，而且现在已经不常用了

//    public static void main(String[] args) {
//        String idCard1 = "101081201505002521"; // 合法
//        System.out.println(isValidDiplomaNumber(idCard1));
//    }


    public static boolean isValidMobileNumber(String mobileNumber) {
        // 手机号必须是11位数字
        if (mobileNumber == null || mobileNumber.length() != 11) {
            return false;
        }

        // 手机号必须以1开头
        if (!mobileNumber.startsWith("1")) {
            return false;
        }

        // 校验手机号第二位数字是否在允许范围内
        // 这里仅列举了常见的几个号段前缀，实际可以根据需要扩展
        String secondDigit = mobileNumber.substring(1, 2);
        if (!"3456789".contains(secondDigit)) {
            return false;
        }

        // 剩余部分必须是数字
        for (int i = 2; i < mobileNumber.length(); i++) {
            if (!Character.isDigit(mobileNumber.charAt(i))) {
                return false;
            }
        }

        // 如果以上校验都通过，则认为手机号格式正确
        return true;
    }


    /**
     * 校验毕业证书编号格式是否正确
     * <p>
     * 假设毕业证书编号规则为：
     * 1. 总长度为18位
     * 2. 前5位为学校编号（这里不验证具体值，只验证长度）
     * 3. 第6位为教育类型代码（这里假设为固定字符，如'G'代表高等教育）
     * 4. 第7-10位为毕业年份（4位数字）
     * 5. 第11-12位为学历层次代码（这里假设为固定两位数字，如'01'代表本科）
     * 6. 后6位为流水号（任意数字）
     *
     * @param diplomaNumber 毕业证书编号
     * @return 毕业证书编号格式是否正确
     */
    public static boolean isValidDiplomaNumber(String diplomaNumber) {
        // 验证长度
        if (diplomaNumber == null || diplomaNumber.length() != 18) {
            return false;
        }


        // 验证剩余部分是否为数字（流水号）
        for (int i = 12; i < diplomaNumber.length(); i++) {
            if (!Character.isDigit(diplomaNumber.charAt(i))) {
                return false;
            }
        }

        // 如果以上校验都通过，则认为毕业证书编号格式正确
        return true;
    }


    public static String HTTPS = "";


    public static String MakeHttpLink(SysOrderOne orderOne) {

        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append(HTTPS).append("?orderId=").append(orderOne.getId());


        String url = new String(stringBuilder);

        return url;
    }


//    public static void main(String[] args) {
////        SysOrderOne order = new SysOrderOne();
////        order.setId(1l);
////        order.setCdName("吕宇宏");
////        order.setPhone("13666666666000");
////        order.setIdNumber("141124200308110076");
////        order.setDegreeCerNo("1145555555555555");
////        String s = MakeHttpLink(order);
////        System.out.println(s);
//
//       boolean s= isEmail("8967452177@qq.ccom");
//        System.out.println(s);
//}

    public static String maskPhoneNumber(String phone) {
        if (phone == null || phone.length() != 11) {
            // 验证手机号是否有效，这里仅检查长度，实际使用时可能需要更严格的验证
            return null;
        }
        // 保留前三位和后四位，其余用*替换
        return phone.substring(0, 3) + "****" + phone.substring(7);
    }
    public static String maskIDCard(String idCard) {
        if (idCard == null || idCard.length() != 18) {
            // 验证身份证号码是否有效，这里仅检查长度
            return null;
        }
        // 保留前6位和最后4位，其余用*替换
        return idCard.substring(0, 6) + "************" + idCard.substring(14);
    }





        /**
         * 从MultipartFile的文件名中提取文件后缀名
         *
         * @param file MultipartFile对象
         * @return 文件后缀名，如果没有后缀名则返回空字符串
         */
        public static String getFileExtension(MultipartFile file) {
            if (file == null || file.getOriginalFilename() == null || file.getOriginalFilename().isEmpty()) {
                return "";
            }

            // 获取文件名
            String filename = file.getOriginalFilename();

            // 查找最后一个点号的位置
            int lastIndexOfDot = filename.lastIndexOf('.');

            // 如果点号不存在，则没有后缀名
            if (lastIndexOfDot == -1) {
                return "";
            }

            // 返回点号之后的所有字符作为文件后缀名
            return filename.substring(lastIndexOfDot + 1);
        }



        @Autowired
    private SysOrderOneMapper orderOneMapper;

        @Autowired
        private SysStoreMapper storeMapper;

        @Autowired
        private SysAgentMapper agentMapper;

        public  String getOrderReportID(Long orderId) {
            SysOrderOne orderOne = orderOneMapper.selectSysOrderOneById(orderId);
            if (orderOne==null) {
                throw new ServiceException("订单不存在");
            }



            StringBuilder stringBuilder = new StringBuilder();
            stringBuilder.append("PBC-");

            Long deptId = orderOne.getDeptId();

            List<SysStore> sysStores = storeMapper.selectSysStoreByDeptId(deptId);
            if (CollectionUtils.isEmpty(sysStores)) {
                throw new ServiceException("订单异常");
            }
            Long agentId = sysStores.get(0).getAgentId();
            SimpleDateFormat dateFormat = new SimpleDateFormat("yyyyMMdd");
            Date date = new Date();

            String format = dateFormat.format(date);
            if (agentId.equals(0l)) {
                //说明是管理端下的商铺
                stringBuilder.append(sysStores.get(0).getMark()+"-");


                stringBuilder.append(format).append(ChuangLanSmsUtil.getRandomYZM());
            }
            else {
                //说明是代理商下的商铺
                SysAgent sysAgent = agentMapper.selectSysAgentById(agentId);
                if (sysAgent==null) {
                    throw new ServiceException("代理商异常");
                }

                stringBuilder.append(sysAgent.getMark()+"-").append(sysStores.get(0).getMark()+"-").append(format).append(ChuangLanSmsUtil.getRandomYZM());

            }

            return stringBuilder.toString();


        }


    /**
     * 使用正则表达式校验邮箱格式
     *
     * @param email 待校验的邮箱地址
     * @return 如果邮箱格式正确，则返回true；否则返回false
     */
    public static boolean isValidEmail(String email) {
        // 简单的电子邮件正则表达式
        // 这个正则表达式不是完美的，但足以覆盖绝大多数电子邮件地址
        String emailRegex = "^[a-zA-Z0-9_+&*-]+(?:\\.[a-zA-Z0-9_+&*-]+)*@" +
                "(?:[a-zA-Z0-9-]+\\.)+[a-zA-Z]{2,7}$";

        // 编译正则表达式
        java.util.regex.Pattern pattern = java.util.regex.Pattern.compile(emailRegex);

        // 匹配输入的字符串
        java.util.regex.Matcher matcher = pattern.matcher(email);

        // 返回匹配结果
        return matcher.matches();
    }





}



